/******************************************************************************
 * Spine Runtimes 许可协议
 * 最后更新：2023 年 7 月 28 日。替代所有先前版本。
 *
 * 版权所有 (c) 2013-2023, Esoteric Software LLC
 *
 * 根据 Spine 编辑器许可协议第 2 条款：http://esotericsoftware.com/spine-editor-license，
 * 允许将 Spine 运行时集成到软件中或创建衍生作品。
 *
 * 使用这些产品的每个用户必须获得各自的 Spine 编辑器许可，
 * 以及在任何形式下重新分发产品时，必须包含本许可证和版权声明。
 *
 * Spine 运行时按“原样”提供，不做任何明示或暗示担保，包括但不限于
 * 适销性和特定用途适用性的暗示担保。在任何情况下，
 * Esoteric Software LLC 均不对因使用 Spine 运行时而产生的任何损害负责。
 *****************************************************************************/

#if UNITY_2018_3 || UNITY_2019 || UNITY_2018_3_OR_NEWER
#define NEW_PREFAB_SYSTEM
#endif

using UnityEngine;

namespace Spine.Unity {

#if NEW_PREFAB_SYSTEM
    [ExecuteAlways]
#else
    [ExecuteInEditMode]
#endif
    [AddComponentMenu("Spine/骨骼动画")]
    [HelpURL("http://esotericsoftware.com/spine-unity#SkeletonAnimation-Component")]
    public class SkeletonAnimation : SkeletonRenderer, ISkeletonAnimation, IAnimationStateComponent {

        #region 动画状态组件接口
        /// <summary>
        /// 此 SkeletonAnimation 的 Spine.AnimationState 对象。用于控制和更新动画。
        /// 注意：此对象（与 .skeleton 类似）在 Awake 时可能尚未创建完毕，
        /// 建议在 Start 中访问并缓存。
        /// </summary>
        [Tooltip("Spine 动画状态对象，用于控制和更新动画")]
        public Spine.AnimationState state;

        /// <summary>
        /// 延迟初始化后获取 Spine.AnimationState 对象。
        /// </summary>
        public Spine.AnimationState AnimationState {
            get {
                Initialize(false);
                return this.state;
            }
        }
        private bool wasUpdatedAfterInit = true;
        #endregion

        #region 骨骼与初始化回调
        protected event ISkeletonAnimationDelegate _OnAnimationRebuild;
        protected event UpdateBonesDelegate _BeforeApply;
        protected event UpdateBonesDelegate _UpdateLocal;
        protected event UpdateBonesDelegate _UpdateWorld;
        protected event UpdateBonesDelegate _UpdateComplete;

        /// <summary>当 SkeletonAnimation 组件成功初始化后触发此回调。</summary>
        public event ISkeletonAnimationDelegate OnAnimationRebuild { add { _OnAnimationRebuild += value; } remove { _OnAnimationRebuild -= value; } }

        /// <summary>
        /// 在骨骼动画应用之前触发此回调。
        /// 可在此处修改骨骼状态，再应用动画。
        /// </summary>
        public event UpdateBonesDelegate BeforeApply { add { _BeforeApply += value; } remove { _BeforeApply -= value; } }

        /// <summary>
        /// 在动画应用完成、转换到世界坐标之前触发此回调。
        /// 可在此处设置骨骼的局部属性。
        /// </summary>
        public event UpdateBonesDelegate UpdateLocal { add { _UpdateLocal += value; } remove { _UpdateLocal -= value; } }

        /// <summary>
        /// 在骨骼世界空间属性（含所有约束）计算完成后触发此回调。
        /// 会额外执行一次世界空间计算，适用于读取并修改局部属性。
        /// </summary>
        public event UpdateBonesDelegate UpdateWorld { add { _UpdateWorld += value; } remove { _UpdateWorld -= value; } }

        /// <summary>
        /// 在骨骼世界空间属性（含所有约束）计算完成后触发此回调。
        /// 仅用于读取世界空间属性，不会修改局部属性，可用于设置世界位置或矩阵。
        /// </summary>
        public event UpdateBonesDelegate UpdateComplete { add { _UpdateComplete += value; } remove { _UpdateComplete -= value; } }

        [InspectorName("更新时机")]
        [Tooltip("动画更新的时机：Update、FixedUpdate 或 LateUpdate")]
        [SerializeField] protected UpdateTiming updateTiming = UpdateTiming.InUpdate;
        public UpdateTiming UpdateTiming { get { return updateTiming; } set { updateTiming = value; } }

        /// <summary>
        /// 启用后，使用非缩放的游戏时间（Time.unscaledDeltaTime）更新动画，
        /// 与游戏暂停（Time.timeScale）无关。
        /// </summary>
        [InspectorName("使用非缩放时间")]
        [Tooltip("是否使用非缩放时间更新动画")]
        [SerializeField] protected bool unscaledTime;
        public bool UnscaledTime { get { return unscaledTime; } set { unscaledTime = value; } }
        #endregion

        [Header("序列化状态与基础 API")]
        #region 序列化状态与基础 API
        [InspectorName("动画名称")]
        [Tooltip("初始播放的动画名称")]
        [SerializeField] [SpineAnimation]
        private string _animationName;

        /// <summary>
        /// 设置此属性可更改骨骼动画。如果名称无效，将在下一次初始化时使用它。
        /// 获取此属性会返回当前播放的动画名称；如果未初始化，则返回最后存储的名称。
        /// </summary>
        public string AnimationName {
            get {
                if (!valid) {
                    return _animationName;
                } else {
                    TrackEntry entry = state.GetCurrent(0);
                    return entry == null ? null : entry.Animation.Name;
                }
            }
            set {
                Initialize(false);
                if (_animationName == value) {
                    TrackEntry entry = state.GetCurrent(0);
                    if (entry != null && entry.Loop == loop)
                        return;
                }
                _animationName = value;

                if (string.IsNullOrEmpty(value)) {
                    state.ClearTrack(0);
                } else {
                    Spine.Animation animationObject = skeletonDataAsset.GetSkeletonData(false).FindAnimation(value);
                    if (animationObject != null)
                        state.SetAnimation(0, animationObject, loop);
                }
            }
        }

        [InspectorName("循环播放")]
        [Tooltip("是否循环播放初始动画")]
        public bool loop;

        [InspectorName("时间缩放")]
        [Tooltip("动画播放速度倍率")]
        public float timeScale = 1;
        #endregion

        #region 运行时实例化
        /// <summary>
        /// 在运行时为指定 GameObject 添加并初始化 SkeletonAnimation 组件。
        /// </summary>
        /// <returns>新创建的 SkeletonAnimation 组件。</returns>
        public static SkeletonAnimation AddToGameObject (GameObject gameObject, SkeletonDataAsset skeletonDataAsset,
            bool quiet = false) {
            return SkeletonRenderer.AddSpineComponent<SkeletonAnimation>(gameObject, skeletonDataAsset, quiet);
        }

        /// <summary>
        /// 实例化一个新的 GameObject，并添加已初始化的 SkeletonAnimation 组件。
        /// </summary>
        /// <returns>新创建的 SkeletonAnimation 组件。</returns>
        public static SkeletonAnimation NewSkeletonAnimationGameObject (SkeletonDataAsset skeletonDataAsset,
            bool quiet = false) {
            return SkeletonRenderer.NewSpineGameObject<SkeletonAnimation>(skeletonDataAsset, quiet);
        }
        #endregion

        /// <summary>
        /// 清除已生成的网格，重置骨骼姿势，并清除所有活动的动画轨迹。
        /// </summary>
        public override void ClearState () {
            base.ClearState();
            if (state != null) state.ClearTracks();
        }

        /// <summary>
        /// 初始化此组件。加载骨骼数据并创建 Spine 内部对象及缓冲区。
        /// </summary>
        /// <param name="overwrite">如果为 true，则强制覆盖已初始化实例。</param>
        public override void Initialize (bool overwrite, bool quiet = false) {
            if (valid && !overwrite)
                return;
#if UNITY_EDITOR
            if (BuildUtilities.IsInSkeletonAssetBuildPreProcessing)
                return;
#endif
            state = null; // 避免残留的动画状态干扰
            base.Initialize(overwrite, quiet);

            if (!valid)
                return;
            state = new Spine.AnimationState(skeletonDataAsset.GetAnimationStateData());
            wasUpdatedAfterInit = false;

            if (!string.IsNullOrEmpty(_animationName)) {
                Spine.Animation animationObject = skeletonDataAsset.GetSkeletonData(false).FindAnimation(_animationName);
                if (animationObject != null) {
                    state.SetAnimation(0, animationObject, loop);
#if UNITY_EDITOR
                    if (!Application.isPlaying)
                        Update(0f);
#endif
                }
            }

            if (_OnAnimationRebuild != null)
                _OnAnimationRebuild(this);
        }

        virtual protected void Update () {
#if UNITY_EDITOR
            if (!Application.isPlaying) {
                Update(0f);
                return;
            }
#endif
            if (updateTiming != UpdateTiming.InUpdate) return;
            Update(unscaledTime ? Time.unscaledDeltaTime : Time.deltaTime);
        }

        virtual protected void FixedUpdate () {
            if (updateTiming != UpdateTiming.InFixedUpdate) return;
            Update(unscaledTime ? Time.unscaledDeltaTime : Time.deltaTime);
        }

        /// <summary>
        /// 以指定的 deltaTime 推进动画状态并应用到骨骼。
        /// 使用 Time.deltaTime 手动驱动；使用 0 可仅应用而不推进时间。
        /// </summary>
        public void Update (float deltaTime) {
            if (!valid || state == null)
                return;

            wasUpdatedAfterInit = true;
            if (updateMode < UpdateMode.OnlyAnimationStatus)
                return;
            UpdateAnimationStatus(deltaTime);

            if (updateMode == UpdateMode.OnlyAnimationStatus)
                return;
            ApplyAnimation();
        }

        protected void UpdateAnimationStatus (float deltaTime) {
            deltaTime *= timeScale;
            state.Update(deltaTime);
            skeleton.Update(deltaTime);

            ApplyTransformMovementToPhysics();

            if (updateMode == UpdateMode.OnlyAnimationStatus) {
                state.ApplyEventTimelinesOnly(skeleton, issueEvents: false);
                return;
            }
        }

        public virtual void ApplyAnimation () {
            if (_BeforeApply != null)
                _BeforeApply(this);

            if (updateMode != UpdateMode.OnlyEventTimelines)
                state.Apply(skeleton);
            else
                state.ApplyEventTimelinesOnly(skeleton, issueEvents: true);

            AfterAnimationApplied();
        }

        public void AfterAnimationApplied () {
            if (_UpdateLocal != null)
                _UpdateLocal(this);

            if (_UpdateWorld == null) {
                UpdateWorldTransform(Skeleton.Physics.Update);
            } else {
                UpdateWorldTransform(Skeleton.Physics.Pose);
                _UpdateWorld(this);
                UpdateWorldTransform(Skeleton.Physics.Update);
            }

            if (_UpdateComplete != null) {
                _UpdateComplete(this);
            }
        }

        public override void LateUpdate () {
            if (updateTiming == UpdateTiming.InLateUpdate && valid)
                Update(unscaledTime ? Time.unscaledDeltaTime : Time.deltaTime);

            // 如果上一次更新尚未执行，则补发一次
            if (!wasUpdatedAfterInit) Update(0);

            base.LateUpdate();
        }

        public override void OnBecameVisible () {
            UpdateMode previousUpdateMode = updateMode;
            updateMode = UpdateMode.FullUpdate;

            // 当对象可见时，确保执行一次完整更新
            if (previousUpdateMode != UpdateMode.FullUpdate &&
                previousUpdateMode != UpdateMode.EverythingExceptMesh)
                Update(0);
            if (previousUpdateMode != UpdateMode.FullUpdate)
                LateUpdate();
        }
    }

}
